/*------------------------------------------------------------------------------
$module:      ManagedObj
$package:     CseApi
$purpose:     managed class
$author:      WAYNE WORK STDIO
$CreateAt:    10/06/01
$LastModify:
$license:     Mozilla Public License Version 1.1
------------------------------------------------------------------------------*/

#include "CseApi_.h"

TInt operator*(TInt i1,const TMngInt& i2)
{ return i1 * (TInt)i2; }

TInt operator/(TInt i1,const TMngInt& i2)
{ return i1 / (TInt)i2; }

TInt operator%(TInt i1,const TMngInt& i2)
{ return i1 % (TInt)i2; }

TInt operator+(TInt i1,const TMngInt& i2)
{ return i1 + (TInt)i2; }

TInt operator-(TInt i1,const TMngInt& i2)
{ return i1 - (TInt)i2; }

TInt operator<<(TInt i1,const TMngInt& i2)
{ return i1 << (TInt)i2; }

TInt operator>>(TInt i1,const TMngInt& i2)
{ return i1 >> (TInt)i2; }

TInt operator&(TInt i1,const TMngInt& i2)
{ return i1 & (TInt)i2; }

TInt operator|(TInt i1,const TMngInt& i2)
{ return i1 | (TInt)i2; }

TInt operator^(TInt i1,const TMngInt& i2)
{ return i1 ^ (TInt)i2; }

TWint operator*(TWint i1,const TMngWint& i2)
{ return i1 * (TWint)i2; }

TWint operator/(TWint i1,const TMngWint& i2)
{ return i1 / (TWint)i2; }

TWint operator%(TWint i1,const TMngWint& i2)
{ return i1 % (TWint)i2; }

TWint operator+(TWint i1,const TMngWint& i2)
{ return i1 + (TWint)i2; }

TWint operator-(TWint i1,const TMngWint& i2)
{ return i1 - (TWint)i2; }

TWint operator<<(TWint i1,const TMngWint& i2)
{ return i1 << (TInt)(TWint)i2; }

TWint operator>>(TWint i1,const TMngWint& i2)
{ return i1 >> (TInt)(TWint)i2; }

TWint operator&(TWint i1,const TMngWint& i2)
{ return i1 & (TWint)i2; }

TWint operator|(TWint i1,const TMngWint& i2)
{ return i1 | (TWint)i2; }

TWint operator^(TWint i1,const TMngWint& i2)
{ return i1 ^ (TWint)i2; }

TDouble operator-(TDouble f1,const TMngFloat& f2)
{ return f1 - (TDouble)f2; }

TDouble operator*(TDouble f1,const TMngFloat& f2)
{ return f1 * (TDouble)f2; }

TDouble operator/(TDouble f1,const TMngFloat& f2)
{ return f1 / (TDouble)f2; }

TDouble operator+(TDouble f1,const TMngFloat& f2)
{ return f1 + (TDouble)f2; }

TCharArray operator+(TXchar x, const TMngStr& y)
{ return x + y.sArray(); }

TCharArray operator+(const TXchar *x, const TMngStr& y)
{ return x + y.sArray(); }

TCharArray operator+(const TCharArray& x, const TMngStr& y)
{ return x + y.sArray(); }

TBool operator==(const TXchar *x, const TMngStr& y)
{ return x == y.sArray(); }

TBool operator==(const TCharArray& x, const TMngStr& y)
{ return x == y.sArray(); }

TBool operator!=(const TXchar *x, const TMngStr& y)
{ return x != y.sArray(); }

TBool operator!=(const TCharArray& x, const TMngStr& y)
{ return x != y.sArray(); }

TBool operator>(const TXchar *x, const TMngStr& y)
{ return x > y.sArray(); }

TBool operator>(const TCharArray& x, const TMngStr& y)
{ return x > y.sArray(); }

TBool operator>=(const TXchar *x, const TMngStr& y)
{ return x >= y.sArray(); }

TBool operator>=(const TCharArray& x, const TMngStr& y)
{ return x >= y.sArray(); }

TBool operator<(const TXchar *x, const TMngStr& y)
{ return x < y.sArray(); }

TBool operator<(const TCharArray& x, const TMngStr& y)
{ return x < y.sArray(); }

TBool operator<=(const TXchar *x, const TMngStr& y)
{ return x <= y.sArray(); }

TBool operator<=(const TCharArray& x, const TMngStr& y)
{ return x <= y.sArray(); }

TBool operator==(const TIntArray& x, const TMngTier& y)
{ return x == y.tArray(); }

TBool operator!=(const TIntArray& x, const TMngTier& y)
{ return x != y.tArray(); }

TBool operator>(const TIntArray& x, const TMngTier& y)
{ return x > y.tArray(); }

TBool operator>=(const TIntArray& x, const TMngTier& y)
{ return x >= y.tArray(); }

TBool operator<(const TIntArray& x, const TMngTier& y)
{ return x < y.tArray(); }

TBool operator<=(const TIntArray& x, const TMngTier& y)
{ return x <= y.tArray(); }

TBool operator==(const TObjArray& x, const TMngBuff& y)
{ return x == y.bArray(); }

TBool operator!=(const TObjArray& x, const TMngBuff& y)
{ return x != y.bArray(); }

TBool operator>(const TObjArray& x, const TMngBuff& y)
{ return x > y.bArray(); }

TBool operator>=(const TObjArray& x, const TMngBuff& y)
{ return x >= y.bArray(); }

TBool operator<(const TObjArray& x, const TMngBuff& y)
{ return x < y.bArray(); }

TBool operator<=(const TObjArray& x, const TMngBuff& y)
{ return x <= y.bArray(); }

TBool operator==(const TEntryArray& x, const TMngDict& y)
{ return x == y.dArray(); }

TBool operator!=(const TEntryArray& x, const TMngDict& y)
{ return x != y.dArray(); }

TInt operator*(TInt i1,const TIntProp& i2)
{ return i1 * (TInt)i2; }

TInt operator/(TInt i1,const TIntProp& i2)
{ return i1 / (TInt)i2; }

TInt operator%(TInt i1,const TIntProp& i2)
{ return i1 % (TInt)i2; }

TInt operator+(TInt i1,const TIntProp& i2)
{ return i1 + (TInt)i2; }

TInt operator-(TInt i1,const TIntProp& i2)
{ return i1 - (TInt)i2; }

TInt operator<<(TInt i1,const TIntProp& i2)
{ return i1 << (TInt)i2; }

TInt operator>>(TInt i1,const TIntProp& i2)
{ return i1 >> (TInt)i2; }

TInt operator&(TInt i1,const TIntProp& i2)
{ return i1 & (TInt)i2; }

TInt operator|(TInt i1,const TIntProp& i2)
{ return i1 | (TInt)i2; }

TInt operator^(TInt i1,const TIntProp& i2)
{ return i1 ^ (TInt)i2; }

TWint operator*(TWint i1,const TWintProp& i2)
{ return i1 * (TWint)i2; }

TWint operator/(TWint i1,const TWintProp& i2)
{ return i1 / (TWint)i2; }

TWint operator%(TWint i1,const TWintProp& i2)
{ return i1 % (TWint)i2; }

TWint operator+(TWint i1,const TWintProp& i2)
{ return i1 + (TWint)i2; }

TWint operator-(TWint i1,const TWintProp& i2)
{ return i1 - (TWint)i2; }

TWint operator<<(TWint i1,const TWintProp& i2)
{ return i1 << (TInt)(TWint)i2; }

TWint operator>>(TWint i1,const TWintProp& i2)
{ return i1 >> (TInt)(TWint)i2; }

TWint operator&(TWint i1,const TWintProp& i2)
{ return i1 & (TWint)i2; }

TWint operator|(TWint i1,const TWintProp& i2)
{ return i1 | (TWint)i2; }

TWint operator^(TWint i1,const TWintProp& i2)
{ return i1 ^ (TWint)i2; }

TDouble operator*(TDouble f1,const TFloatProp& f2)
{ return f1 * (TDouble)f2; }

TDouble operator/(TDouble f1,const TFloatProp& f2)
{ return f1 / (TDouble)f2; }

TDouble operator+(TDouble f1,const TFloatProp& f2)
{ return f1 + (TDouble)f2; }

TDouble operator-(TDouble f1,const TFloatProp& f2)
{ return f1 - (TDouble)f2; }

TCharArray operator+(TXchar x, const TStrProp& y)
{
    TCharArray s(x);
    s += (const TXchar*)y;
    return TCharArray(CUT_FROM,s);
}

TCharArray operator+(const TXchar *x, const TStrProp& y)
{ 
    TCharArray s(x);
    s += (const TXchar*)y;
    return TCharArray(CUT_FROM,s);
}

TCharArray operator+(const TCharArray& x, const TStrProp& y)
{
    return x + (const TXchar*)y;
}

TBool operator==(const TXchar *x, const TStrProp& y)
{
    TCharArray s(x);
    return s.compare((const TXchar*)y) == 0;
}

TBool operator==(const TCharArray& x, const TStrProp& y)
{
    return x == (const TXchar*)y;
}

TBool operator!=(const TXchar *x, const TStrProp& y)
{
    TCharArray s(x);
    return s.compare((const TXchar*)y) != 0;
}

TBool operator!=(const TCharArray& x, const TStrProp& y)
{
    return x != (const TXchar*)y;
}

TBool operator>(const TXchar *x, const TStrProp& y)
{
    TCharArray s(x);
    return s.compare((const TXchar*)y) > 0;
}

TBool operator>(const TCharArray& x, const TStrProp& y)
{
    return x > (const TXchar*)y;
}

TBool operator>=(const TXchar *x, const TStrProp& y)
{
    TCharArray s(x);
    return s.compare((const TXchar*)y) >= 0;
}

TBool operator>=(const TCharArray& x, const TStrProp& y)
{
    return x >= (const TXchar*)y;
}

TBool operator<(const TXchar *x, const TStrProp& y)
{
    TCharArray s(x);
    return s.compare((const TXchar*)y) < 0;
}

TBool operator<(const TCharArray& x, const TStrProp& y)
{
    return x < (const TXchar*)y;
}

TBool operator<=(const TXchar *x, const TStrProp& y)
{
    TCharArray s(x);
    return s.compare((const TXchar*)y) <= 0;
}

TBool operator<=(const TCharArray& x, const TStrProp& y)
{
    return x <= (const TXchar*)y;
}
